home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / distutils / msvccompiler.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  18KB  |  644 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''distutils.msvccompiler
  5.  
  6. Contains MSVCCompiler, an implementation of the abstract CCompiler class
  7. for the Microsoft Visual Studio.
  8. '''
  9. __revision__ = '$Id: msvccompiler.py 54645 2007-04-01 18:29:47Z neal.norwitz $'
  10. import sys
  11. import os
  12. import string
  13. from distutils.errors import DistutilsExecError, DistutilsPlatformError, CompileError, LibError, LinkError
  14. from distutils.ccompiler import CCompiler, gen_preprocess_options, gen_lib_options
  15. from distutils import log
  16. _can_read_reg = 0
  17.  
  18. try:
  19.     import _winreg
  20.     _can_read_reg = 1
  21.     hkey_mod = _winreg
  22.     RegOpenKeyEx = _winreg.OpenKeyEx
  23.     RegEnumKey = _winreg.EnumKey
  24.     RegEnumValue = _winreg.EnumValue
  25.     RegError = _winreg.error
  26. except ImportError:
  27.     
  28.     try:
  29.         import win32api
  30.         import win32con
  31.         _can_read_reg = 1
  32.         hkey_mod = win32con
  33.         RegOpenKeyEx = win32api.RegOpenKeyEx
  34.         RegEnumKey = win32api.RegEnumKey
  35.         RegEnumValue = win32api.RegEnumValue
  36.         RegError = win32api.error
  37.     except ImportError:
  38.         log.info("Warning: Can't read registry to find the necessary compiler setting\nMake sure that Python modules _winreg, win32api or win32con are installed.")
  39.     except:
  40.         None<EXCEPTION MATCH>ImportError
  41.     
  42.  
  43.     None<EXCEPTION MATCH>ImportError
  44.  
  45. if _can_read_reg:
  46.     HKEYS = (hkey_mod.HKEY_USERS, hkey_mod.HKEY_CURRENT_USER, hkey_mod.HKEY_LOCAL_MACHINE, hkey_mod.HKEY_CLASSES_ROOT)
  47.  
  48.  
  49. def read_keys(base, key):
  50.     '''Return list of registry keys.'''
  51.     
  52.     try:
  53.         handle = RegOpenKeyEx(base, key)
  54.     except RegError:
  55.         return None
  56.  
  57.     L = []
  58.     i = 0
  59.     while None:
  60.         
  61.         try:
  62.             k = RegEnumKey(handle, i)
  63.         except RegError:
  64.             break
  65.  
  66.         i = i + 1
  67.         continue
  68.         return L
  69.  
  70.  
  71. def read_values(base, key):
  72.     '''Return dict of registry keys and values.
  73.  
  74.     All names are converted to lowercase.
  75.     '''
  76.     
  77.     try:
  78.         handle = RegOpenKeyEx(base, key)
  79.     except RegError:
  80.         return None
  81.  
  82.     d = { }
  83.     i = 0
  84.     while None:
  85.         
  86.         try:
  87.             (name, value, type) = RegEnumValue(handle, i)
  88.         except RegError:
  89.             break
  90.  
  91.         name = name.lower()
  92.         d[convert_mbcs(name)] = convert_mbcs(value)
  93.         i = i + 1
  94.         continue
  95.         return d
  96.  
  97.  
  98. def convert_mbcs(s):
  99.     enc = getattr(s, 'encode', None)
  100.     if enc is not None:
  101.         
  102.         try:
  103.             s = enc('mbcs')
  104.         except UnicodeError:
  105.             pass
  106.         except:
  107.             None<EXCEPTION MATCH>UnicodeError
  108.         
  109.  
  110.     None<EXCEPTION MATCH>UnicodeError
  111.     return s
  112.  
  113.  
  114. class MacroExpander:
  115.     
  116.     def __init__(self, version):
  117.         self.macros = { }
  118.         self.load_macros(version)
  119.  
  120.     
  121.     def set_macro(self, macro, path, key):
  122.         for base in HKEYS:
  123.             d = read_values(base, path)
  124.             if d:
  125.                 self.macros['$(%s)' % macro] = d[key]
  126.                 break
  127.                 continue
  128.         
  129.  
  130.     
  131.     def load_macros(self, version):
  132.         vsbase = 'Software\\Microsoft\\VisualStudio\\%0.1f' % version
  133.         self.set_macro('VCInstallDir', vsbase + '\\Setup\\VC', 'productdir')
  134.         self.set_macro('VSInstallDir', vsbase + '\\Setup\\VS', 'productdir')
  135.         net = 'Software\\Microsoft\\.NETFramework'
  136.         self.set_macro('FrameworkDir', net, 'installroot')
  137.         
  138.         try:
  139.             if version > 7:
  140.                 self.set_macro('FrameworkSDKDir', net, 'sdkinstallrootv1.1')
  141.             else:
  142.                 self.set_macro('FrameworkSDKDir', net, 'sdkinstallroot')
  143.         except KeyError:
  144.             exc = None
  145.             raise DistutilsPlatformError, 'Python was built with Visual Studio 2003;\nextensions must be built with a compiler than can generate compatible binaries.\nVisual Studio 2003 was not found on this system. If you have Cygwin installed,\nyou can try compiling with MingW32, by passing "-c mingw32" to setup.py.'
  146.  
  147.         p = 'Software\\Microsoft\\NET Framework Setup\\Product'
  148.         for base in HKEYS:
  149.             
  150.             try:
  151.                 h = RegOpenKeyEx(base, p)
  152.             except RegError:
  153.                 continue
  154.  
  155.             key = RegEnumKey(h, 0)
  156.             d = read_values(base, '%s\\%s' % (p, key))
  157.             self.macros['$(FrameworkVersion)'] = d['version']
  158.         
  159.  
  160.     
  161.     def sub(self, s):
  162.         for k, v in self.macros.items():
  163.             s = string.replace(s, k, v)
  164.         
  165.         return s
  166.  
  167.  
  168.  
  169. def get_build_version():
  170.     '''Return the version of MSVC that was used to build Python.
  171.  
  172.     For Python 2.3 and up, the version number is included in
  173.     sys.version.  For earlier versions, assume the compiler is MSVC 6.
  174.     '''
  175.     prefix = 'MSC v.'
  176.     i = string.find(sys.version, prefix)
  177.     if i == -1:
  178.         return 6
  179.     
  180.     i = i + len(prefix)
  181.     (s, rest) = sys.version[i:].split(' ', 1)
  182.     majorVersion = int(s[:-2]) - 6
  183.     minorVersion = int(s[2:3]) / 10
  184.     if majorVersion == 6:
  185.         minorVersion = 0
  186.     
  187.     if majorVersion >= 6:
  188.         return majorVersion + minorVersion
  189.     
  190.  
  191.  
  192. def get_build_architecture():
  193.     '''Return the processor architecture.
  194.  
  195.     Possible results are "Intel", "Itanium", or "AMD64".
  196.     '''
  197.     prefix = ' bit ('
  198.     i = string.find(sys.version, prefix)
  199.     if i == -1:
  200.         return 'Intel'
  201.     
  202.     j = string.find(sys.version, ')', i)
  203.     return sys.version[i + len(prefix):j]
  204.  
  205.  
  206. def normalize_and_reduce_paths(paths):
  207.     '''Return a list of normalized paths with duplicates removed.
  208.  
  209.     The current order of paths is maintained.
  210.     '''
  211.     reduced_paths = []
  212.     for p in paths:
  213.         np = os.path.normpath(p)
  214.         if np not in reduced_paths:
  215.             reduced_paths.append(np)
  216.             continue
  217.     
  218.     return reduced_paths
  219.  
  220.  
  221. class MSVCCompiler(CCompiler):
  222.     '''Concrete class that implements an interface to Microsoft Visual C++,
  223.        as defined by the CCompiler abstract class.'''
  224.     compiler_type = 'msvc'
  225.     executables = { }
  226.     _c_extensions = [
  227.         '.c']
  228.     _cpp_extensions = [
  229.         '.cc',
  230.         '.cpp',
  231.         '.cxx']
  232.     _rc_extensions = [
  233.         '.rc']
  234.     _mc_extensions = [
  235.         '.mc']
  236.     src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
  237.     res_extension = '.res'
  238.     obj_extension = '.obj'
  239.     static_lib_extension = '.lib'
  240.     shared_lib_extension = '.dll'
  241.     static_lib_format = shared_lib_format = '%s%s'
  242.     exe_extension = '.exe'
  243.     
  244.     def __init__(self, verbose = 0, dry_run = 0, force = 0):
  245.         CCompiler.__init__(self, verbose, dry_run, force)
  246.         self._MSVCCompiler__version = get_build_version()
  247.         self._MSVCCompiler__arch = get_build_architecture()
  248.         if self._MSVCCompiler__arch == 'Intel':
  249.             if self._MSVCCompiler__version >= 7:
  250.                 self._MSVCCompiler__root = 'Software\\Microsoft\\VisualStudio'
  251.                 self._MSVCCompiler__macros = MacroExpander(self._MSVCCompiler__version)
  252.             else:
  253.                 self._MSVCCompiler__root = 'Software\\Microsoft\\Devstudio'
  254.             self._MSVCCompiler__product = 'Visual Studio version %s' % self._MSVCCompiler__version
  255.         else:
  256.             self._MSVCCompiler__product = 'Microsoft SDK compiler %s' % (self._MSVCCompiler__version + 6)
  257.         self.initialized = False
  258.  
  259.     
  260.     def initialize(self):
  261.         self._MSVCCompiler__paths = []
  262.         if os.environ.has_key('DISTUTILS_USE_SDK') and os.environ.has_key('MSSdk') and self.find_exe('cl.exe'):
  263.             self.cc = 'cl.exe'
  264.             self.linker = 'link.exe'
  265.             self.lib = 'lib.exe'
  266.             self.rc = 'rc.exe'
  267.             self.mc = 'mc.exe'
  268.         else:
  269.             self._MSVCCompiler__paths = self.get_msvc_paths('path')
  270.             if len(self._MSVCCompiler__paths) == 0:
  271.                 raise DistutilsPlatformError, "Python was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed." % self._MSVCCompiler__product
  272.             
  273.             self.cc = self.find_exe('cl.exe')
  274.             self.linker = self.find_exe('link.exe')
  275.             self.lib = self.find_exe('lib.exe')
  276.             self.rc = self.find_exe('rc.exe')
  277.             self.mc = self.find_exe('mc.exe')
  278.             self.set_path_env_var('lib')
  279.             self.set_path_env_var('include')
  280.         
  281.         try:
  282.             for p in string.split(os.environ['path'], ';'):
  283.                 self._MSVCCompiler__paths.append(p)
  284.         except KeyError:
  285.             pass
  286.  
  287.         self._MSVCCompiler__paths = normalize_and_reduce_paths(self._MSVCCompiler__paths)
  288.         os.environ['path'] = string.join(self._MSVCCompiler__paths, ';')
  289.         self.preprocess_options = None
  290.         if self._MSVCCompiler__arch == 'Intel':
  291.             self.compile_options = [
  292.                 '/nologo',
  293.                 '/Ox',
  294.                 '/MD',
  295.                 '/W3',
  296.                 '/GX',
  297.                 '/DNDEBUG']
  298.             self.compile_options_debug = [
  299.                 '/nologo',
  300.                 '/Od',
  301.                 '/MDd',
  302.                 '/W3',
  303.                 '/GX',
  304.                 '/Z7',
  305.                 '/D_DEBUG']
  306.         else:
  307.             self.compile_options = [
  308.                 '/nologo',
  309.                 '/Ox',
  310.                 '/MD',
  311.                 '/W3',
  312.                 '/GS-',
  313.                 '/DNDEBUG']
  314.             self.compile_options_debug = [
  315.                 '/nologo',
  316.                 '/Od',
  317.                 '/MDd',
  318.                 '/W3',
  319.                 '/GS-',
  320.                 '/Z7',
  321.                 '/D_DEBUG']
  322.         self.ldflags_shared = [
  323.             '/DLL',
  324.             '/nologo',
  325.             '/INCREMENTAL:NO']
  326.         if self._MSVCCompiler__version >= 7:
  327.             self.ldflags_shared_debug = [
  328.                 '/DLL',
  329.                 '/nologo',
  330.                 '/INCREMENTAL:no',
  331.                 '/DEBUG']
  332.         else:
  333.             self.ldflags_shared_debug = [
  334.                 '/DLL',
  335.                 '/nologo',
  336.                 '/INCREMENTAL:no',
  337.                 '/pdb:None',
  338.                 '/DEBUG']
  339.         self.ldflags_static = [
  340.             '/nologo']
  341.         self.initialized = True
  342.  
  343.     
  344.     def object_filenames(self, source_filenames, strip_dir = 0, output_dir = ''):
  345.         if output_dir is None:
  346.             output_dir = ''
  347.         
  348.         obj_names = []
  349.         for src_name in source_filenames:
  350.             (base, ext) = os.path.splitext(src_name)
  351.             base = os.path.splitdrive(base)[1]
  352.             base = base[os.path.isabs(base):]
  353.             if ext not in self.src_extensions:
  354.                 raise CompileError("Don't know how to compile %s" % src_name)
  355.             
  356.             if strip_dir:
  357.                 base = os.path.basename(base)
  358.             
  359.             if ext in self._rc_extensions:
  360.                 obj_names.append(os.path.join(output_dir, base + self.res_extension))
  361.                 continue
  362.             if ext in self._mc_extensions:
  363.                 obj_names.append(os.path.join(output_dir, base + self.res_extension))
  364.                 continue
  365.             obj_names.append(os.path.join(output_dir, base + self.obj_extension))
  366.         
  367.         return obj_names
  368.  
  369.     
  370.     def compile(self, sources, output_dir = None, macros = None, include_dirs = None, debug = 0, extra_preargs = None, extra_postargs = None, depends = None):
  371.         if not self.initialized:
  372.             self.initialize()
  373.         
  374.         (macros, objects, extra_postargs, pp_opts, build) = self._setup_compile(output_dir, macros, include_dirs, sources, depends, extra_postargs)
  375.         if not extra_preargs:
  376.             pass
  377.         compile_opts = []
  378.         compile_opts.append('/c')
  379.         if debug:
  380.             compile_opts.extend(self.compile_options_debug)
  381.         else:
  382.             compile_opts.extend(self.compile_options)
  383.         for obj in objects:
  384.             
  385.             try:
  386.                 (src, ext) = build[obj]
  387.             except KeyError:
  388.                 continue
  389.  
  390.             if debug:
  391.                 src = os.path.abspath(src)
  392.             
  393.             if ext in self._c_extensions:
  394.                 input_opt = '/Tc' + src
  395.             elif ext in self._cpp_extensions:
  396.                 input_opt = '/Tp' + src
  397.             elif ext in self._rc_extensions:
  398.                 input_opt = src
  399.                 output_opt = '/fo' + obj
  400.                 
  401.                 try:
  402.                     self.spawn([
  403.                         self.rc] + pp_opts + [
  404.                         output_opt] + [
  405.                         input_opt])
  406.                 continue
  407.                 except DistutilsExecError:
  408.                     msg = None
  409.                     raise CompileError, msg
  410.                     continue
  411.                 
  412.  
  413.             elif ext in self._mc_extensions:
  414.                 h_dir = os.path.dirname(src)
  415.                 rc_dir = os.path.dirname(obj)
  416.                 
  417.                 try:
  418.                     self.spawn([
  419.                         self.mc] + [
  420.                         '-h',
  421.                         h_dir,
  422.                         '-r',
  423.                         rc_dir] + [
  424.                         src])
  425.                     (base, _) = os.path.splitext(os.path.basename(src))
  426.                     rc_file = os.path.join(rc_dir, base + '.rc')
  427.                     self.spawn([
  428.                         self.rc] + [
  429.                         '/fo' + obj] + [
  430.                         rc_file])
  431.                 continue
  432.                 except DistutilsExecError:
  433.                     msg = None
  434.                     raise CompileError, msg
  435.                     continue
  436.                 
  437.  
  438.             else:
  439.                 raise CompileError("Don't know how to compile %s to %s" % (src, obj))
  440.             output_opt = '/Fo' + obj
  441.             
  442.             try:
  443.                 self.spawn([
  444.                     self.cc] + compile_opts + pp_opts + [
  445.                     input_opt,
  446.                     output_opt] + extra_postargs)
  447.             continue
  448.             except DistutilsExecError:
  449.                 msg = None
  450.                 raise CompileError, msg
  451.                 continue
  452.             
  453.  
  454.         
  455.         return objects
  456.  
  457.     
  458.     def create_static_lib(self, objects, output_libname, output_dir = None, debug = 0, target_lang = None):
  459.         if not self.initialized:
  460.             self.initialize()
  461.         
  462.         (objects, output_dir) = self._fix_object_args(objects, output_dir)
  463.         output_filename = self.library_filename(output_libname, output_dir = output_dir)
  464.         if self._need_link(objects, output_filename):
  465.             lib_args = objects + [
  466.                 '/OUT:' + output_filename]
  467.             if debug:
  468.                 pass
  469.             
  470.             
  471.             try:
  472.                 self.spawn([
  473.                     self.lib] + lib_args)
  474.             except DistutilsExecError:
  475.                 msg = None
  476.                 raise LibError, msg
  477.             except:
  478.                 None<EXCEPTION MATCH>DistutilsExecError
  479.             
  480.  
  481.         None<EXCEPTION MATCH>DistutilsExecError
  482.         log.debug('skipping %s (up-to-date)', output_filename)
  483.  
  484.     
  485.     def link(self, target_desc, objects, output_filename, output_dir = None, libraries = None, library_dirs = None, runtime_library_dirs = None, export_symbols = None, debug = 0, extra_preargs = None, extra_postargs = None, build_temp = None, target_lang = None):
  486.         if not self.initialized:
  487.             self.initialize()
  488.         
  489.         (objects, output_dir) = self._fix_object_args(objects, output_dir)
  490.         (libraries, library_dirs, runtime_library_dirs) = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
  491.         if runtime_library_dirs:
  492.             self.warn("I don't know what to do with 'runtime_library_dirs': " + str(runtime_library_dirs))
  493.         
  494.         lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
  495.         if output_dir is not None:
  496.             output_filename = os.path.join(output_dir, output_filename)
  497.         
  498.         if self._need_link(objects, output_filename):
  499.             if target_desc == CCompiler.EXECUTABLE:
  500.                 if debug:
  501.                     ldflags = self.ldflags_shared_debug[1:]
  502.                 else:
  503.                     ldflags = self.ldflags_shared[1:]
  504.             elif debug:
  505.                 ldflags = self.ldflags_shared_debug
  506.             else:
  507.                 ldflags = self.ldflags_shared
  508.             export_opts = []
  509.             for sym in []:
  510.                 export_opts.append('/EXPORT:' + sym)
  511.             ld_args = ldflags + lib_opts + export_opts + objects + [
  512.                 '/OUT:' + output_filename]
  513.             if export_symbols is not None:
  514.                 (dll_name, dll_ext) = os.path.splitext(os.path.basename(output_filename))
  515.                 implib_file = os.path.join(os.path.dirname(objects[0]), self.library_filename(dll_name))
  516.                 ld_args.append('/IMPLIB:' + implib_file)
  517.             
  518.             if extra_preargs:
  519.                 ld_args[:0] = extra_preargs
  520.             
  521.             if extra_postargs:
  522.                 ld_args.extend(extra_postargs)
  523.             
  524.             self.mkpath(os.path.dirname(output_filename))
  525.             
  526.             try:
  527.                 self.spawn([
  528.                     self.linker] + ld_args)
  529.             except DistutilsExecError:
  530.                 msg = None
  531.                 raise LinkError, msg
  532.             except:
  533.                 None<EXCEPTION MATCH>DistutilsExecError
  534.             
  535.  
  536.         None<EXCEPTION MATCH>DistutilsExecError
  537.         log.debug('skipping %s (up-to-date)', output_filename)
  538.  
  539.     
  540.     def library_dir_option(self, dir):
  541.         return '/LIBPATH:' + dir
  542.  
  543.     
  544.     def runtime_library_dir_option(self, dir):
  545.         raise DistutilsPlatformError, "don't know how to set runtime library search path for MSVC++"
  546.  
  547.     
  548.     def library_option(self, lib):
  549.         return self.library_filename(lib)
  550.  
  551.     
  552.     def find_library_file(self, dirs, lib, debug = 0):
  553.         if debug:
  554.             try_names = [
  555.                 lib + '_d',
  556.                 lib]
  557.         else:
  558.             try_names = [
  559.                 lib]
  560.         for dir in dirs:
  561.             for name in try_names:
  562.                 libfile = os.path.join(dir, self.library_filename(name))
  563.                 if os.path.exists(libfile):
  564.                     return libfile
  565.                     continue
  566.             
  567.         else:
  568.             return None
  569.  
  570.     
  571.     def find_exe(self, exe):
  572.         """Return path to an MSVC executable program.
  573.  
  574.         Tries to find the program in several places: first, one of the
  575.         MSVC program search paths from the registry; next, the directories
  576.         in the PATH environment variable.  If any of those work, return an
  577.         absolute path that is known to exist.  If none of them work, just
  578.         return the original program name, 'exe'.
  579.         """
  580.         for p in self._MSVCCompiler__paths:
  581.             fn = os.path.join(os.path.abspath(p), exe)
  582.             if os.path.isfile(fn):
  583.                 return fn
  584.                 continue
  585.         
  586.         for p in string.split(os.environ['Path'], ';'):
  587.             fn = os.path.join(os.path.abspath(p), exe)
  588.             if os.path.isfile(fn):
  589.                 return fn
  590.                 continue
  591.         
  592.         return exe
  593.  
  594.     
  595.     def get_msvc_paths(self, path, platform = 'x86'):
  596.         '''Get a list of devstudio directories (include, lib or path).
  597.  
  598.         Return a list of strings.  The list will be empty if unable to
  599.         access the registry or appropriate registry keys not found.
  600.         '''
  601.         if not _can_read_reg:
  602.             return []
  603.         
  604.         path = path + ' dirs'
  605.         if self._MSVCCompiler__version >= 7:
  606.             key = '%s\\%0.1f\\VC\\VC_OBJECTS_PLATFORM_INFO\\Win32\\Directories' % (self._MSVCCompiler__root, self._MSVCCompiler__version)
  607.         else:
  608.             key = '%s\\6.0\\Build System\\Components\\Platforms\\Win32 (%s)\\Directories' % (self._MSVCCompiler__root, platform)
  609.         for base in HKEYS:
  610.             d = read_values(base, key)
  611.             if d:
  612.                 if self._MSVCCompiler__version >= 7:
  613.                     return string.split(self._MSVCCompiler__macros.sub(d[path]), ';')
  614.                 else:
  615.                     return string.split(d[path], ';')
  616.             self._MSVCCompiler__version >= 7
  617.         
  618.         if self._MSVCCompiler__version == 6:
  619.             for base in HKEYS:
  620.                 if read_values(base, '%s\\6.0' % self._MSVCCompiler__root) is not None:
  621.                     self.warn('It seems you have Visual Studio 6 installed, but the expected registry settings are not present.\nYou must at least run the Visual Studio GUI once so that these entries are created.')
  622.                     break
  623.                     continue
  624.             
  625.         
  626.         return []
  627.  
  628.     
  629.     def set_path_env_var(self, name):
  630.         """Set environment variable 'name' to an MSVC path type value.
  631.  
  632.         This is equivalent to a SET command prior to execution of spawned
  633.         commands.
  634.         """
  635.         if name == 'lib':
  636.             p = self.get_msvc_paths('library')
  637.         else:
  638.             p = self.get_msvc_paths(name)
  639.         if p:
  640.             os.environ[name] = string.join(p, ';')
  641.         
  642.  
  643.  
  644.